/*
 * Quercia Luciano
 * Algoritmi e Strutture Dati
 * a.a. 2009-10
 */


#ifndef _NODOG_H_
#define _NODOG_H_

#include "lista/lista.h"

template <class T>
class NodoG {
public:
	NodoG();
	NodoG(T);
	~NodoG();

	typedef NodoG<T> cella;
	typedef NodoG<T> * nodo;

	//Operatori
	T getValue() const;
	int getArchi() const;
	Lista<nodo> getList() const;
	bool getMark() const;

	void setValue(T);
	void setArchi(int);
	void setList(Lista<nodo>);
	void setMark(bool);

	bool operator==(NodoG<T>);

	void insAdiacente( nodo ) throw (char const *) ;
	void cancAdiacente( nodo ) throw (char const *) ;

private:
	typedef NodoL< nodo > * posizione;

	T value;
	bool mark;
	int archi;
	Lista<nodo> list;
};



/*****************************
 *        DEFINIZIONI        *
 *     dei metodi di Nodo    *
 *****************************/

template <class T>
NodoG<T>::NodoG() {
	mark = true;
	archi = 0;
}

template <class T>
NodoG<T>::NodoG( T elem ) {
	mark = true;
	archi = 0;
	value = elem;
}


template <class T>
NodoG<T>::~NodoG() {
	list.~Lista();
}


template <class T>
T NodoG<T>::getValue() const {
	return value;
}


template <class T>
int NodoG<T>::getArchi() const {
	return archi;
}

template <class T>
Lista<typename NodoG<T>::nodo> NodoG<T>::getList() const{
	return list;
}

template <class T>
bool NodoG<T>::getMark() const {
	return mark;
}


template <class T>
void NodoG<T>::setValue(T elem) {
	value = elem ;
}

template <class T>
void NodoG<T>::setArchi(int archi) {
	this->archi = archi;
}

template <class T>
void NodoG<T>::setList(Lista<nodo> list) {
	this->list = list;
}

template <class T>
void NodoG<T>::setMark(bool mark) {
	this->mark = mark;
}


template <class T>
bool NodoG<T>::operator==(NodoG<T> n) {
	return this->getValue() == n.getValue();
}


template <class T>
void NodoG<T>::insAdiacente( NodoG<T>::nodo cellaP ) throw (char const *) {
	posizione p;
	p = list.primoLista();
	while (!list.fineLista(p)) {
		if (list.leggiLista(p) == cellaP)
			throw "Arco già presente.";
		p = list.succLista(p);
	}

	p = list.primoLista();
	list.insLista( cellaP, p );
	archi++;
}


template <class T>
void NodoG<T>::cancAdiacente( NodoG<T>::nodo cellaP ) throw (char const *) {
	posizione p;
	bool trovato = false;

	p = list.primoLista();
	while (!list.fineLista(p)) {
		if (list.leggiLista(p) == cellaP) {
			trovato = true;
			list.cancLista(p);
			archi--;
		}
		p = list.succLista(p);
	}

	if (!trovato)
		throw "Arco non presente.";

}


#endif
